Java Optional 使用

参考资料如何更好地使用Java 8的Optional 参考资料 [Java8] 如何正确使用 Optional 大量转载自沉默王二建议收藏，史上最佳 Java Optional 指南，没有之一

Optional 是什么？

Optional 是 Java 8 里面的特性，主要为了解决 null 安全问题的一个 API（避免写大量的 null 值检查）

没有 Optional 会有什么问题

模拟一个实际的应用场景，从数据库中根据会员 ID 拉取一个会员的姓名，然后将姓名打印到控制台。

public class WithoutOptionalDemo {
    class Member {
        private String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

    public static void main(String[] args) {
        Member mem = getMemberByIdFromDB();
        if (mem != null) {
            System.out.println(mem.getName());
        }
    }

    public static Member getMemberByIdFromDB() {
        // 当前 ID 的会员不存在
        return null;
    }
}

由于当前 ID 的会员不存在，所以 getMemberByIdFromDB() 方法返回了 null 来作为没有获取到该会员的结果，那就意味着在打印会员姓名的时候要先对 mem 判空，否则就会抛出 NPE 异常

Exception in thread "main" java.lang.NullPointerException
    at com.example.optional.WithoutOptionalDemo.main(WithoutOptionalDemo.java:24)

Optional 是如何解决这个问题的

使用 Optional，可以避免没有必要的 null 值检查

public class OptionalDemo {
    public static void main(String[] args) {
        Optional<Member> optional = getMemberByIdFromDB();
        optional.ifPresent(mem -> {
            System.out.println("会员姓名是：" + mem.getName());
        });
    }

    public static Optional<Member> getMemberByIdFromDB() {
        boolean hasName = true;
        if (hasName) {
            return Optional.of(new Member("沉默王二"));
        }
        return Optional.empty();
    }
}
class Member {
    private String name;

    public String getName() {
        return name;
    }

    // getter / setter
}

getMemberByIdFromDB() 方法返回了 Optional<Member> 作为结果，这样就表明 Member 可能存在，也可能不存在，这时候就可以在 Optional 的 ifPresent() 方法中使用 Lambda 表达式来直接打印结果。

Optional 之所以可以解决 NPE 的问题，是因为它明确的告诉我们，不需要对它进行判空。它就好像十字路口的路标，明确地告诉你该往哪走。

创建 Optional 对象

可以使用静态方法 empty() 创建一个空的 Optional 对象

Optional<String> empty = Optional.empty();
System.out.println(empty); // 输出：Optional.empty

可以使用静态方法 of() 创建一个非空的 Optional 对象

Optional<String> opt = Optional.of("沉默王二");
System.out.println(opt); // 输出：Optional[沉默王二]

当然了，传递给 of() 方法的参数必须是非空的，也就是说不能为 null，否则仍然会抛出 NullPointerException。

String name = null;
Optional<String> optnull = Optional.of(name);

可以使用静态方法 ofNullable() 创建一个即可空又可非空的 Optional 对象

String name = null;
Optional<String> optOrNull = Optional.ofNullable(name);
System.out.println(optOrNull); // 输出：Optional.empty

ofNullable() 方法内部有一个三元表达式，如果为参数为 null，则返回私有常量 EMPTY；否则使用 new 关键字创建了一个新的 Optional 对象——不会再抛出 NPE 异常了。

判断值是否存在

可以通过方法 isPresent() 判断一个 Optional 对象是否存在，如果存在，该方法返回 true，否则返回 false 取代了 obj != null 的判断。

Optional<String> opt = Optional.of("沉默王二");
System.out.println(opt.isPresent()); // 输出：true

Optional<String> optOrNull = Optional.ofNullable(null);
System.out.println(opt.isPresent()); // 输出：false

Java 11 后还可以通过方法 isEmpty() 判断与 isPresent() 相反的结果。

Optional<String> opt = Optional.of("沉默王二");
System.out.println(opt.isPresent()); // 输出：true

Optional<String> optOrNull = Optional.ofNullable(null);
System.out.println(optOrNull.isEmpty()); // 输出：true

如果不为空执行方法⭐

Optional 类有一个非常现代化的方法 ifPresent()，允许我们使用函数式编程的方式执行一些代码，因此，我把它称为非空表达式。

Optional.ofNullable(comp).ifPresent(System.out::println);

如果没有该方法的话，我们通常需要先通过 isPresent() 方法对 Optional 对象进行判空后再执行相应的代码：

Optional<String> optOrNull = Optional.ofNullable(null);
if (optOrNull.isPresent()) {
    System.out.println(optOrNull.get().length());
}

有了 ifPresent() 之后，情况就完全不同了，可以直接将 Lambda 表达式传递给该方法，代码更加简洁，更加直观。

Optional.of("沉默王二").ifPresent(str -> System.out.println(str.length()));

Java 9 后还可以通过方法 ifPresentOrElse(action, emptyAction) 执行两种结果，非空时执行 action，空时执行 emptyAction。

Optional<String> opt = Optional.of("沉默王二");
opt.ifPresentOrElse(str -> System.out.println(str.length()), () -> System.out.println("为空"));

使用示例

注意：这里只是演示如何使用，但是这个例子其实不可取（脱裤子放屁）

if (tmp != null && tmp.getSpaceCode() != null && !tmp.getSpaceCode().equals(spaceVO.getSpaceCode())) {
    int spaceCode = count(new SimpleCondition().andEqual("spaceCode", spaceVO.getSpaceCode()));
    if (spaceCode != 0) {
        throw new BusinessException("修改失败，当前已经存在该空间编码，禁止修改！");
    }
}

可以该写成

Optional.ofNullable(tmp).map(SpaceVO::getSpaceCode).ifPresent(code -> {
    if (code.equals(spaceVO.getSpaceCode())) {
        int spaceCode = count(new SimpleCondition().andEqual("spaceCode", spaceVO.getSpaceCode()));
        if (spaceCode != 0) {
            throw new BusinessException("修改失败，当前已经存在该空间编码，禁止修改！");
        }
    }
});

设置（获取）默认值

有时候，我们在创建（获取） Optional 对象的时候，需要一个默认值，orElse() 和 orElseGet() 方法就派上用场了。

orElse() 方法用于返回包裹在 Optional 对象中的值，如果该值不为 null，则返回；否则返回默认值。该方法的参数类型和值得类型一致。

String nullName = null;
String name = Optional.ofNullable(nullName).orElse("沉默王二");
System.out.println(name); // 输出：沉默王二

orElseGet() 方法与 orElse() 方法类似，但参数类型不同。如果 Optional 对象中的值为 null，则执行参数中的函数。

String nullName = null;
String name = Optional.ofNullable(nullName).orElseGet(()->"沉默王二");
System.out.println(name); // 输出：沉默王二

抛出异常 orElseThrow

orElseThrow() 是在当遭遇 Null时，决定抛出哪个 Exception时使用：

Stream<String> names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");
Optional<String> longest = names
                        .filter(name -> name.startsWith("Q"))
                        .findFirst();

longest.orElseThrow(NoSuchElementStartingWithQException::new);

获取值 orElseGet

直观从语义上来看，get() 方法才是最正宗的获取 Optional 对象值的方法，但很遗憾，该方法是有缺陷的，因为假如 Optional 对象的值为 null，该方法会抛出 NoSuchElementException 异常。这完全与我们使用 Optional 类的初衷相悖。

public class GetOptionalDemo {
    public static void main(String[] args) {
        String name = null;
        Optional<String> optOrNull = Optional.ofNullable(name);
        System.out.println(optOrNull.get());
    }
}

这段程序在运行时会抛出异常：

Exception in thread "main" java.util.NoSuchElementException: No value present
    at java.base/java.util.Optional.get(Optional.java:141)
    at com.example.optional.GetOptionalDemo.main(GetOptionalDemo.java:9)

所以一般使用 orElseGet() 取值，这个方法内部如下，如果不为空就返回那个值，为空返回默认值

public T orElseGet(Supplier<? extends T> supplier) {
    return value != null ? value : supplier.get();
}

过滤值 filter

例如在用户注册时对密码的长度进行检查时就可以用 Optional 类的 filter() 方法

public class FilterOptionalDemo {
    public static void main(String[] args) {
        String password = "12345";
        Optional<String> opt = Optional.ofNullable(password);
        System.out.println(opt.filter(pwd -> pwd.length() > 6).isPresent());
    }
}

filter() 方法的参数类型为 Predicate（Java 8 新增的一个函数式接口），也就是说可以将一个 Lambda 表达式传递给该方法作为条件，如果表达式的结果为 false，则返回一个 EMPTY 的 Optional 对象，否则返回过滤后的 Optional 对象。

由于 password 的长度为 5 ，所以程序输出的结果为 false。假设密码的长度要求在 6 到 10 位之间，那么还可以再追加一个条件。

Predicate<String> len6 = pwd -> pwd.length() > 6;
Predicate<String> len10 = pwd -> pwd.length() < 10;

password = "1234567";
opt = Optional.ofNullable(password);
boolean result = opt.filter(len6.and(len10)).isPresent();
System.out.println(result);

这次程序输出的结果为 true，因为密码变成了 7 位，在 6 到 10 位之间。想像如果使用 if-else 来完成这个任务，代码该有多冗长...

转换值 map

map() 方法可以按照一定的规则将原有 Optional 对象转换为一个新的 Optional 对象，原有的 Optional 对象不会更改。

先来写一个简单的例子：

public class OptionalMapDemo {
    public static void main(String[] args) {
        String name = "沉默王二";
        Optional<String> nameOptional = Optional.of(name);

        Optional<Integer> intOpt = nameOptional
                .map(String::length);
        
        System.out.println( intOpt.orElse(0));
    }
}

在上面这个例子中，map() 方法的参数 String::length，意味着要将原有的字符串类型的 Optional 按照字符串长度重新生成一个新的 Optional 对象，类型为 Integer。

这里可以搭配上面的 filter() 方法一起使用

public class OptionalMapFilterDemo {
    public static void main(String[] args) {
        String password = "password";
        Optional<String>  opt = Optional.ofNullable(password);

        Predicate<String> len6 = pwd -> pwd.length() > 6;
        Predicate<String> len10 = pwd -> pwd.length() < 10;
        Predicate<String> eq = pwd -> pwd.equals("password");

        boolean result = opt.map(String::toLowerCase).filter(len6.and(len10 ).and(eq)).isPresent();
        System.out.println(result);
    }
}

如何正确使用 Optional

其实 Optional 应该搭配 Lambda大礼包一起使用才够味（方法引用）

如下例子：

public static String getChampionName(Competition comp) throws IllegalArgumentException {
    if (comp != null) {
        CompResult result = comp.getResult();
        if (result != null) {
            User champion = result.getChampion();
            if (champion != null) {
                return champion.getName();
            }
        }
    }
    throw new IllegalArgumentException("The value of param comp isn't available.");
}

而其他语言比如 kotlin，就提供了在语法层面的操作符加持：

comp?.getResult()?.getChampion()?.getName()

经过 Optional 加持过后，也可以有 ? 关键字的效果，核心就是这个 map 方法，注意！！！！

这个 map 其实逻辑就是当前面那个不为空时再映射到下一个

public static String getChampionName(Competition comp) throws IllegalArgumentException {
    return Optional.ofNullable(comp)
            .map(Competition::getResult)  // 相当于c -> c.getResult()，下同
            .map(CompResult::getChampion)
            .map(User::getName)
            .orElseThrow(()->new IllegalArgumentException("The value of param comp isn't available."));
}

比如字符串为空则不打印可以这么写：

string.ifPresent(System.out::println);

Optional 是什么？​

没有 Optional 会有什么问题​

Optional 是如何解决这个问题的​

创建 Optional 对象​

判断值是否存在​

如果不为空执行方法⭐​

使用示例​

设置（获取）默认值​

抛出异常 orElseThrow​

获取值 orElseGet​

过滤值 filter​

转换值 map​

如何正确使用 Optional​